home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1998 April: Mac OS SDK / Dev.CD Apr 98 SDK1.toast / Development Kits (Disc 1) / Interfaces&Libraries / Universal / Interfaces / PInterfaces / PCCard.p < prev    next >
Encoding:
Text File  |  1998-02-12  |  22.8 KB  |  495 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        PCCard.p
  3.  
  4.      Contains:    PC Card Family Programming interface
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Release:    Universal Interfaces 3.1
  8.  
  9.      Copyright:    © 1996-1998 by Apple Computer, Inc.  All rights reserved.
  10.  
  11.      Bugs?:        Please include the the file and version information (from above) with
  12.                  the problem description.  Developers belonging to one of the Apple
  13.                  developer programs can submit bug reports to:
  14.  
  15.                      devsupport@apple.com
  16.  
  17. }
  18. {$IFC UNDEFINED UsingIncludes}
  19. {$SETC UsingIncludes := 0}
  20. {$ENDC}
  21.  
  22. {$IFC NOT UsingIncludes}
  23.  UNIT PCCard;
  24.  INTERFACE
  25. {$ENDC}
  26.  
  27. {$IFC UNDEFINED __PCCARD__}
  28. {$SETC __PCCARD__ := 1}
  29.  
  30. {$I+}
  31. {$SETC PCCardIncludes := UsingIncludes}
  32. {$SETC UsingIncludes := 1}
  33.  
  34. {$IFC UNDEFINED __MACTYPES__}
  35. {$I MacTypes.p}
  36. {$ENDC}
  37. {$IFC UNDEFINED __NAMEREGISTRY__}
  38. {$I NameRegistry.p}
  39. {$ENDC}
  40.  
  41.  
  42. {$PUSH}
  43. {$ALIGN POWER}
  44. {$LibExport+}
  45.  
  46.  
  47. CONST
  48.     kServiceCategoryPCCard        = 'pccd';
  49.  
  50.  
  51.  
  52. TYPE
  53.     PCCardEvent                            = UInt32;
  54.     PCCardEventMask                        = UInt32;
  55.     PCCardClientID                        = UInt32;
  56.     PCCardTimerID                        = UInt32;
  57.     PCCardSocket                        = UInt32;
  58.     PCCardWindowID                        = UInt32;
  59.     PCCardWindowType                    = UInt32;
  60.     PCCardWindowSize                    = UInt32;
  61.     PCCardWindowOffset                    = UInt32;
  62.     PCCardWindowAlign                    = UInt32;
  63.     PCCardWindowState                    = OptionBits;
  64.     PCCardAccessSpeed                    = UInt32;
  65.     PCCardWindowParam                    = UInt32;
  66.     PCCardPage                            = UInt32;
  67.     PCCardVoltage                        = UInt32;
  68. {
  69.     Several of the client notification bit flags have been REMOVED since the first
  70.     release of this header.  These were unused codes that were either
  71.     copied directly from PC Card 2.x, or from the PCMCIA standard.  In all cases,
  72.     they were completely unimplemented and would never be sent under PCCard 3.0.
  73.     
  74.     The removed flags are:
  75.         kPCCardClientInfoMessage, kPCCardSSUpdatedMessage,
  76.         and kPCCardFunctionInterruptMessage.
  77.     
  78.     If your software used any of these flags, you should delete any references
  79.     to them.  These event codes are being recycled for new features.
  80. }
  81. { Client notification bit flags }
  82.  
  83. CONST
  84.     kPCCardNullMessage            = $00000000;                    {  no messages pending (not sent to clients) }
  85.     kPCCardInsertionMessage        = $00000001;                    {  card has been inserted into the socket }
  86.     kPCCardRemovalMessage        = $00000002;                    {  card has been removed from the socket- do not touch hardware! }
  87.                                                                 {  Lock and Unlock may be used for a hardware locking card-cage.  }
  88.     kPCCardLockMessage            = $00000004;                    {  card is locked into the socket with a mechanical latch  }
  89.     kPCCardUnlockMessage        = $00000008;                    {  card is no longer locked into the socket  }
  90.                                                                 {  Ready and Reset are holdovers from PC Card 2.x, but someone might be using them (!?)  }
  91.     kPCCardReadyMessage            = $00000010;                    {  card is ready to be accessed -- do not use! this event is never sent! (use kPCCardInsertion instead)  }
  92.     kPCCardResetMessage            = $00000020;                    {  physical reset has completed -- do not use! this event is never sent! (use kPCCardResetComplete instead)  }
  93.                                                                 {  InsertionRequest and InsertionComplete may be used with certain cages (??)  }
  94.     kPCCardInsertionRequestMessage = $00000040;                    {  request to insert a card using insertion motor  }
  95.     kPCCardInsertionCompleteMessage = $00000080;                {  insertion motor has finished inserting a card  }
  96.     kPCCardEjectionRequestMessage = $00000100;                    {  user or other client is requesting a card ejection }
  97.     kPCCardEjectionCompleteMessage = $00000200;                    {  card ejection succeeded- do not touch hardware!  }
  98.     kPCCardEjectionFailedMessage = $00000400;                    {  eject failure due to electrical/mechanical problems }
  99.     kPCCardPMResumeMessage        = $00000800;                    {  power management resume  }
  100.     kPCCardPMSuspendMessage        = $00001000;                    {  power management suspend  }
  101.     kPCCardPMSuspendRequest        = $00002000;                    {  power management sleep request  }
  102.     kPCCardPMSuspendRevoke        = $00004000;                    {  power management sleep revoke  }
  103.     kPCCardResetPhysicalMessage    = $00008000;                    {  physical reset is about to occur on this card -- this event is never sent!  }
  104.     kPCCardResetRequestMessage    = $00010000;                    {  physical reset has been requested by a client }
  105.     kPCCardResetCompleteMessage    = $00020000;                    {  ResetCard() background reset has completed }
  106.     kPCCardBatteryDeadMessage    = $00040000;                    {  battery is no longer useable, data will be lost }
  107.     kPCCardBatteryLowMessage    = $00080000;                    {  battery is weak and should be replaced }
  108.     kPCCardWriteProtectMessage    = $00100000;                    {  card is now write protected }
  109.     kPCCardWriteEnabledMessage    = $00200000;                    {  card is now write enabled }
  110.     kPCCardUnexpectedRemovalMessage = $02000000;                {  card has unexpectedly been manually ejected -- careful, this event occurs at hardware interrupt time  }
  111.                                                                 {  Unconfigured is a (currently unused) holdover from PC Card 2.x  }
  112.     kPCCardUnconfiguredMessage    = $04000000;                    {  a CARD_READY was delivered to all clients and no client  }
  113.                                                                 {     requested a configuration for the socket -- this event is never sent under PCCard 3.0!  }
  114.     kPCCardStatusChangedMessage    = $08000000;                    {  status change for cards in I/O mode }
  115.     kPCCardTimerExpiredMessage    = $10000000;                    {  message sent when requested time has expired  }
  116.     kPCCardRequestAttentionMessage = $20000000;
  117.     kPCCardEraseCompleteMessage    = $40000000;
  118.     kPCCardRegistrationCompleteMessage = $80000000;                {  notifications available only in PCCard 3.1 and later  }
  119.     kPCCardPMEnabledMessage        = $00800000;                    {  power management has been enabled by the user; if appropriate, clients should call PCCardSetPowerLevel(off)  }
  120.  
  121.  
  122. TYPE
  123.     PCCardWindowAttributes                = OptionBits;
  124. {    window state (values of PCCardWindowAttributes) }
  125.  
  126. CONST
  127.     kWSCommon                    = $0001;                        {  common memory window  }
  128.     kWSAttribute                = $0002;                        {  attribute memory window }
  129.     kWSIO                        = $0004;                        {  I/O window }
  130.     kWSCardBus                    = $0800;                        {  CardBus bridge window  }
  131.     kWSTypeMask                    = $0807;                        {  window type mask }
  132.     kWSEnabled                    = $0008;                        {  window enabled }
  133.     kWS8bit                        = $0010;                        {  8-bit data width window }
  134.     kWS16bit                    = $0020;                        {  16-bit data width window }
  135.     kWS32bit                    = $0040;                        {  32-bit data width window }
  136.     kWSAutoSize                    = $0080;                        {  auto-size data width window }
  137.     kWSWidthMask                = $00F0;                        {  window data width mask }
  138.     kWSProtected                = $0100;                        {  window write protected }
  139.     kWSPrefetchable                = $0200;                        {  bridge window prefetchable }
  140.     kWSPageShared                = $0400;                        {  page register is shared }
  141.     kWSWindowSizeOffset            = $4000;
  142.     kWSChangeAccessSpeed        = $8000;                        {  Used by CSModifyWindow only  }
  143.  
  144. { window speed (sample values of PCCardAccessSpeed) for use in PCCardRequestWindow  }
  145.     kAccessSpeed600ns            = $006A;
  146.     kAccessSpeed500ns            = $005A;
  147.     kAccessSpeed400ns            = $004A;
  148.     kAccessSpeed300ns            = $003A;
  149.     kAccessSpeed250ns            = $0001;
  150.     kAccessSpeed200ns            = $0002;
  151.     kAccessSpeed150ns            = $0003;
  152.     kAccessSpeed100ns            = $0004;
  153.  
  154.  
  155. TYPE
  156.     PCCardInterfaceType                    = UInt32;
  157. { InterfaceType bit-mask (values of PCCardInterfaceType) }
  158.  
  159. CONST
  160.     kIFTypeMask                    = $03;                            {  IO & memory type mask }
  161.     kIFCardBus                    = $00;                            {  if bits 0 & 1 are zero then cardbus interface }
  162.     kIFMemory                    = $01;                            {  if bit 0 set memory IF }
  163.     kIFIO                        = $02;                            {  if bit 1 set IO IF }
  164.     kIFReserved                    = $03;                            {  bits 0 and 1 set is reserved  }
  165.     kIFDMA                        = $08;                            {  if bit 3 set DMA supported }
  166.     kIFVSKey                    = $10;                            {  if bit 4 set supports low Voltage key }
  167.     kIF33VCC                    = $20;                            {  if bit 5 set socket suports 3.3v }
  168.     kIFXXVCC                    = $40;                            {  if bit 6 set socket supports X.X voltage }
  169.     kIFYYVCC                    = $80;                            {  if bit 7 set socket supports Y.Y voltage }
  170.  
  171.  
  172. TYPE
  173.     PCCardCustomInterfaceID                = UInt32;
  174. { Custom Interface Identifiers (values of PCCardCustomInterfaceID) }
  175.  
  176. CONST
  177.     kIFCustom_None                = $00;                            {  no custom interface ID  }
  178.     kIFCustom_ZOOM                = $41;                            {  ZOOM Video Mode custom interface identifier  }
  179.  
  180.  
  181. TYPE
  182.     PCCardConfigOptions                    = OptionBits;
  183. { Bit mask values for PCCardConfigOptions in the configuration calls }
  184.  
  185. CONST
  186.     kEnableIRQSteering            = $0002;
  187.     kIRQChangeValid                = $0004;
  188.     kVppChangeValid                = $0010;
  189.     kEnableDMAChannel            = $0040;
  190.     kDMAChangeValid                = $0080;
  191.     kVSOverride                    = $0200;                        {  Bits 10..31 reserved  }
  192.  
  193. {
  194.    Configuration Registers Presence Mask for the FCR
  195.    Used by PCCardConfigPresentMask
  196. }
  197.     kConfigOptionPresent        = $00000001;
  198.     kConfigStatusPresent        = $00000002;
  199.     kPinReplacePresent            = $00000004;
  200.     kSocketCopyPresent            = $00000008;
  201.     kExtendedStatusPresent        = $00000010;
  202.     kIOBase0Present                = $00000020;
  203.     kIOBase1Present                = $00000040;
  204.     kIOBase2Present                = $00000080;
  205.     kIOBase3Present                = $00000100;
  206.     kIOLimitPresent                = $00000200;
  207.  
  208.  
  209. TYPE
  210.     PCCardConfigPresentMask                = UInt32;
  211.     PCCardConfigRegisterIndex            = UInt32;
  212.     PCCardConfigRegisterOffset            = UInt32;
  213.     PCCardFunctionConfigRegPtr = ^PCCardFunctionConfigReg;
  214.     PCCardFunctionConfigReg = RECORD
  215.         configOptionReg:        SInt8;
  216.         configStatusReg:        SInt8;
  217.         pinReplaceReg:            SInt8;
  218.         socketCopyReg:            SInt8;
  219.         extendedStatusReg:        SInt8;
  220.         ioBase0:                SInt8;
  221.         ioBase1:                SInt8;
  222.         ioBase2:                SInt8;
  223.         ioBase3:                SInt8;
  224.         ioLimit:                SInt8;
  225.     END;
  226.  
  227.     PCCardSocketStatus                    = OptionBits;
  228. {    general socket status bits (values of PCCardSocketStatus) }
  229.  
  230. CONST
  231.     kSTBatteryDead                = $0001;                        {  battery dead }
  232.     kSTBatteryLow                = $0002;                        {  battery low }
  233.     kSTBatteryGood                = $0004;                        {  battery good }
  234.     kSTPower                    = $0008;                        {  power is applied }
  235.     kST16bit                    = $0010;                        {  16-bit PC Card present }
  236.     kSTCardBus                    = $0020;                        {  CardBus PC Card present }
  237.     kSTMemoryCard                = $0040;                        {  memory card present }
  238.     kSTIOCard                    = $0080;                        {  I/O card present }
  239.     kSTNotACard                    = $0100;                        {  unrecognizable PC Card detected }
  240.     kSTReady                    = $0200;                        {  ready }
  241.     kSTWriteProtect                = $0400;                        {  card is write-protected }
  242.     kSTDataLost                    = $0800;                        {  data may have been lost due to card removal }
  243.     kSTRingIndicate                = $1000;                        {  ring indicator is active }
  244.     kSTReserved                    = $E000;
  245.  
  246. { Bit mask for PCCardPowerOptions in the power management calls }
  247.  
  248. TYPE
  249.     PCCardPowerOptions                    = OptionBits;
  250.  
  251. CONST
  252.     kPCCardPowerOn                = $00000001;
  253.     kPCCardPowerOff                = $00000002;
  254.     kPCCardLowPower                = $00000004;
  255.  
  256.  
  257. TYPE
  258.     PCCardAdapterCapabilities            = OptionBits;
  259.     PCCardAdapterPowerState                = UInt32;
  260.     PCCardSCEvents                        = OptionBits;
  261.     PCCardWindow                        = UInt32;
  262.     PCCardIRQ                            = UInt32;
  263.     PCCardDMA                            = UInt32;
  264. { Selectors for PCCardGetGlobalOptions }
  265. {    The type of the "value" parameter is provided for each selector. }
  266.     PCCardOptionSelector                = UInt32;
  267.  
  268. CONST
  269.     kPCCardPowerManagementAttrib = 1;                            {  value = (Boolean*) enabled   }
  270.  
  271.  
  272.  
  273. {  Types and structures for accessing the PCCard Assigned-Address property. }
  274.  
  275.     kPCCardNonRelocatableSpace    = $80;
  276.     kPCCardPrefetchableSpace    = $40;
  277.     kPCCard16BitSpace            = $20;
  278.     kPCCardAddressTypeCodeMask    = $07;
  279.     kPCCardConfigSpace            = 0;
  280.     kPCCardIOSpace                = 1;
  281.     kPCCardMemorySpace            = 2;
  282.     kPCCardAttributeMemorySpace    = 4;
  283.  
  284.  
  285. TYPE
  286.     PCCardAddressSpaceFlags                = UInt8;
  287.  
  288. CONST
  289.     kPCCardSocketNumberMask        = $F8;
  290.     kPCCardFunctionNumberMask    = $07;
  291.  
  292.  
  293. TYPE
  294.     PCCardSocketFunction                = UInt8;
  295.     PCCardBusNumber                        = UInt8;
  296.     PCCardRegisterNumber                = UInt8;
  297. {
  298.    note: this structure is similar, but not the same as the PCIAssignedAddress structure
  299.          16-bit cards use this structure, CardBus cards use PCIAssignedAddress
  300. }
  301.     PCCardAssignedAddressPtr = ^PCCardAssignedAddress;
  302.     PCCardAssignedAddress = PACKED RECORD
  303.         addressSpaceFlags:        PCCardAddressSpaceFlags;
  304.         reserved:                UInt8;
  305.         socketFunctionNumber:    PCCardSocketFunction;
  306.         registerNumber:            PCCardRegisterNumber;
  307.         address:                UInt32;
  308.         size:                    UInt32;
  309.     END;
  310.  
  311. {----------------------------------------------------------------------
  312.     Client Support
  313. ----------------------------------------------------------------------}
  314. { Prototype for client callback }
  315. {$IFC TYPED_FUNCTION_POINTERS}
  316.     PCCardEventHandler = FUNCTION(theEvent: PCCardEvent; vSocket: PCCardSocket; device: UInt32; info: UInt32; MTDRequest: UInt32; VAR Buffer: UInt32; misc: UInt32; status: UInt32; clientParam: UNIV Ptr): OSStatus; C;
  317. {$ELSEC}
  318.     PCCardEventHandler = ProcPtr;
  319. {$ENDC}
  320.  
  321. FUNCTION PCCardRegisterClient({CONST}VAR deviceRef: RegEntryID; eventMask: PCCardEventMask; clientCallBack: PCCardEventHandler; clientParam: UNIV Ptr; VAR newClientID: PCCardClientID): OSStatus; C;
  322. FUNCTION PCCardDeRegisterClient(theClientID: PCCardClientID): OSStatus; C;
  323. FUNCTION PCCardRegisterTimer(registeredClientID: PCCardClientID; VAR lpNewTimerID: PCCardTimerID; delay: LONGINT): OSStatus; C;
  324. PROCEDURE PCCardDeRegisterTimer(timerID: PCCardTimerID); C;
  325. FUNCTION PCCardSetEventMask(theClientID: PCCardClientID; newEventMask: PCCardEventMask): OSStatus; C;
  326. FUNCTION PCCardGetEventMask(theClientID: PCCardClientID; VAR newEventMask: PCCardEventMask): OSStatus; C;
  327. FUNCTION PCCardGetCardServicesInfo(VAR socketCount: ItemCount; VAR complianceLevel: UInt32; VAR version: UInt32): OSStatus; C;
  328. FUNCTION PCCardGetSocketRef(vSocket: PCCardSocket; VAR socketRef: RegEntryID): OSStatus; C;
  329. FUNCTION PCCardGetCardRef(vSocket: PCCardSocket; VAR cardRef: RegEntryID): OSStatus; C;
  330. FUNCTION PCCardGetDeviceRef(vSocket: PCCardSocket; device: UInt32; VAR deviceRef: RegEntryID): OSStatus; C;
  331. FUNCTION PCCardGetSocketAndDeviceFromDeviceRef({CONST}VAR deviceRef: RegEntryID; VAR vSocket: PCCardSocket; VAR device: UInt32): OSStatus; C;
  332. FUNCTION PCCardGetCardRefFromDeviceRef({CONST}VAR deviceRef: RegEntryID; VAR cardRef: RegEntryID): OSStatus; C;
  333.  
  334. {----------------------------------------------------------------------
  335.     Resource Management
  336. ----------------------------------------------------------------------}
  337. FUNCTION PCCardRequestWindow({CONST}VAR deviceRef: RegEntryID; windowAttributes: PCCardWindowAttributes; VAR windowBase: LogicalAddress; VAR windowSize: ByteCount; VAR windowSpeed: PCCardAccessSpeed; VAR windowOffset: PCCardWindowOffset; VAR windowID: PCCardWindowID): OSStatus; C;
  338. FUNCTION PCCardModifyWindow(windowID: PCCardWindowID; windowAttributes: PCCardWindowAttributes; windowSpeed: PCCardAccessSpeed; windowOffset: PCCardWindowOffset): OSStatus; C;
  339. FUNCTION PCCardReleaseWindow(windowID: PCCardWindowID): OSStatus; C;
  340. FUNCTION PCCardInquireWindow({CONST}VAR deviceRef: RegEntryID; windowID: PCCardWindowID; VAR windowAttributes: PCCardWindowAttributes; VAR windowBase: LogicalAddress; VAR windowSize: ByteCount; VAR windowSpeed: PCCardAccessSpeed; VAR windowOffset: PCCardWindowOffset): OSStatus; C;
  341. FUNCTION PCCardGetStatus({CONST}VAR deviceRef: RegEntryID; VAR currentState: UInt32; VAR changedState: UInt32; VAR Vcc: PCCardVoltage; VAR Vpp: PCCardVoltage): OSStatus; C;
  342. FUNCTION PCCardRequestConfiguration({CONST}VAR deviceRef: RegEntryID; configOptions: PCCardConfigOptions; ifType: PCCardInterfaceType; ifCustomType: PCCardCustomInterfaceID; vcc: PCCardVoltage; vpp: PCCardVoltage; configRegistersBase: LogicalAddress; configRegistersPresent: PCCardConfigPresentMask; VAR configRegisterValues: PCCardFunctionConfigReg): OSStatus; C;
  343. FUNCTION PCCardReleaseConfiguration({CONST}VAR deviceRef: RegEntryID): OSStatus; C;
  344. FUNCTION PCCardModifyConfiguration({CONST}VAR deviceRef: RegEntryID; configOptions: PCCardConfigOptions; vpp: PCCardVoltage): OSStatus; C;
  345. FUNCTION PCCardReadConfigurationRegister({CONST}VAR deviceRef: RegEntryID; whichRegister: PCCardConfigRegisterIndex; offset: PCCardConfigRegisterOffset; VAR value: UInt8): OSStatus; C;
  346. FUNCTION PCCardWriteConfigurationRegister({CONST}VAR deviceRef: RegEntryID; whichRegister: PCCardConfigRegisterIndex; offset: PCCardConfigRegisterOffset; value: ByteParameter): OSStatus; C;
  347. FUNCTION PCCardResetFunction({CONST}VAR deviceRef: RegEntryID): OSStatus; C;
  348. {----------------------------------------------------------------------
  349.     Client Utilities
  350. ----------------------------------------------------------------------}
  351.  
  352. TYPE
  353.     PCCardTupleKind                        = UInt8;
  354.     PCCardTupleIterator = ^LONGINT;
  355. FUNCTION PCCardNewTupleIterator: PCCardTupleIterator; C;
  356. FUNCTION PCCardDisposeTupleIterator(tupleIterator: PCCardTupleIterator): OSStatus; C;
  357. FUNCTION PCCardGetFirstTuple({CONST}VAR deviceID: RegEntryID; desiredTuple: ByteParameter; tupleIterator: PCCardTupleIterator; dataBuffer: UNIV Ptr; VAR dataBufferSize: UInt32; VAR foundTuple: PCCardTupleKind; VAR foundTupleDataSize: UInt32): OSStatus; C;
  358. FUNCTION PCCardGetNextTuple({CONST}VAR deviceRef: RegEntryID; desiredTuple: ByteParameter; tupleIterator: PCCardTupleIterator; dataBuffer: UNIV Ptr; VAR dataBufferSize: UInt32; VAR foundTuple: PCCardTupleKind; VAR foundTupleDataSize: UInt32): OSStatus; C;
  359. {----------------------------------------------------------------------
  360.     Miscellaneous
  361. ----------------------------------------------------------------------}
  362. FUNCTION PCCardEject({CONST}VAR cardRef: RegEntryID): OSStatus; C;
  363. FUNCTION PCCardEnableModemSound({CONST}VAR cardRef: RegEntryID; enableSound: BOOLEAN): OSStatus; C;
  364. FUNCTION PCCardEnableZoomedVideoSound({CONST}VAR cardRef: RegEntryID; enableSound: BOOLEAN): OSStatus; C;
  365. FUNCTION PCCardSetPowerLevel({CONST}VAR deviceRef: RegEntryID; powerLevel: PCCardPowerOptions): OSStatus; C;
  366. FUNCTION PCCardSetRingIndicate({CONST}VAR deviceRef: RegEntryID; setRingIndicate: BOOLEAN): OSStatus; C;
  367. FUNCTION PCCardGetGlobalOptions(selector: PCCardOptionSelector; value: UNIV Ptr): OSStatus; C;
  368.  
  369. TYPE
  370.     PCCardDevType                        = UInt32;
  371.     PCCardSubType                        = UInt32;
  372. {  values for PCCardType and PCCardSubType }
  373.  
  374. CONST
  375.     kPCCardUnknownType            = 0;
  376.     kPCCardMultiFunctionType    = 1;
  377.     kPCCardMemoryType            = 2;
  378.     kPCCardNullSubType            = 0;                            {  Memory sub types  }
  379.     kPCCardRomSubType            = 1;
  380.     kPCCardOTPromSubType        = 2;
  381.     kPCCardEpromSubType            = 3;
  382.     kPCCardEEpromSubType        = 4;
  383.     kPCCardFlashSubType            = 5;
  384.     kPCCardSramSubType            = 6;
  385.     kPCCardDramSubType            = 7;
  386.     kPCCardSerialPortType        = 3;
  387.     kPCCardSerialOnlySubType    = 0;
  388.     kPCCardDataModemSubType        = 1;
  389.     kPCCardFaxModemSubType        = 2;
  390.     kPCCardFaxAndDataModemMask    = 3;
  391.     kPCCardVoiceEncodingSubType    = 4;
  392.     kPCCardParallelPortType        = 4;
  393.     kPCCardFixedDiskType        = 5;
  394.     kPCCardUnknownFixedDiskType    = 0;
  395.     kPCCardATAInterfaceDiskSubType = 1;
  396.     kPCCardRotatingDeviceSubType = $00;
  397.     kPCCardSiliconDevice        = $80;
  398.     kPCCardVideoAdaptorType        = 6;
  399.     kPCCardNetworkAdaptorType    = 7;
  400.     kPCCardArcNetSubType        = 1;                            {  network sub types  }
  401.     kPCCardEthernetSubType        = 2;
  402.     kPCCardTokenRingSubType        = 3;
  403.     kPCCardLocalTalkSubType        = 4;
  404.     kPCCardFDDI_CDDISubType        = 5;
  405.     kPCCardATMSubType            = 6;
  406.     kPCCardWirelessSubType        = 7;
  407.     kPCCardAIMSType                = 8;
  408.     kPCCardSCSIType                = 9;
  409.  
  410. FUNCTION PCCardGetCardInfo({CONST}VAR cardRef: RegEntryID; VAR cardType: PCCardDevType; VAR cardSubType: PCCardSubType; cardName: StringPtr; vendorName: StringPtr): OSStatus; C;
  411.  
  412. CONST
  413.     kPCCard16HardwareType        = 'pc16';
  414.     kCardBusHardwareType        = 'cdbs';
  415.  
  416.  
  417. TYPE
  418.     PCCardHardwareType                    = UInt32;
  419. FUNCTION PCCardGetCardType({CONST}VAR socketRef: RegEntryID; VAR cardType: PCCardHardwareType): OSStatus; C;
  420. { error codes }
  421.  
  422. CONST
  423.     kBadAdapterErr                = -9050;                        {  invalid adapter number }
  424.     kBadAttributeErr            = -9051;                        {  specified attributes field value is invalid }
  425.     kBadBaseErr                    = -9052;                        {  specified base system memory address is invalid }
  426.     kBadEDCErr                    = -9053;                        {  specified EDC generator specified is invalid }
  427.     kBadIRQErr                    = -9054;                        {  specified IRQ level is invalid }
  428.     kBadOffsetErr                = -9055;                        {  specified PC card memory array offset is invalid }
  429.     kBadPageErr                    = -9056;                        {  specified page is invalid }
  430.     kBadSizeErr                    = -9057;                        {  specified size is invalid }
  431.     kBadSocketErr                = -9058;                        {  specified logical or physical socket number is invalid }
  432.     kBadTypeErr                    = -9059;                        {  specified window or interface type is invalid }
  433.     kBadVccErr                    = -9060;                        {  specified Vcc power level index is invalid }
  434.     kBadVppErr                    = -9061;                        {  specified Vpp1 or Vpp2 power level index is invalid }
  435.     kBadWindowErr                = -9062;                        {  specified window is invalid }
  436.     kBadArgLengthErr            = -9063;                        {  ArgLength argument is invalid }
  437.     kBadArgsErr                    = -9064;                        {  values in argument packet are invalid }
  438.     kBadHandleErr                = -9065;                        {  clientHandle is invalid }
  439.     kBadCISErr                    = -9066;                        {  CIS on card is invalid }
  440.     kBadSpeedErr                = -9067;                        {  specified speed is unavailable }
  441.     kReadFailureErr                = -9068;                        {  unable to complete read request }
  442.     kWriteFailureErr            = -9069;                        {  unable to complete write request }
  443.     kGeneralFailureErr            = -9070;                        {  an undefined error has occurred }
  444.     kNoCardErr                    = -9071;                        {  no PC card in the socket }
  445.     kUnsupportedFunctionErr        = -9072;                        {  function is not supported by this implementation }
  446.     kUnsupportedModeErr            = -9073;                        {  mode is not supported }
  447.     kBusyErr                    = -9074;                        {  unable to process request at this time - try later }
  448.     kWriteProtectedErr            = -9075;                        {  media is write-protected }
  449.     kConfigurationLockedErr        = -9076;                        {  a configuration has already been locked }
  450.     kInUseErr                    = -9077;                        {  requested resource is being used by a client }
  451.     kNoMoreItemsErr                = -9078;                        {  there are no more of the requested item }
  452.     kOutOfResourceErr            = -9079;                        {  Card Services has exhausted the resource }
  453.     kNoCardSevicesSocketsErr    = -9080;
  454.     kInvalidRegEntryErr            = -9081;
  455.     kBadLinkErr                    = -9082;
  456.     kBadDeviceErr                = -9083;
  457.     k16BitCardErr                = -9084;
  458.     kCardBusCardErr                = -9085;
  459.     kPassCallToChainErr            = -9086;
  460.     kCantConfigureCardErr        = -9087;
  461.     kPostCardEventErr            = -9088;                        {  _PCCSLPostCardEvent failed and dropped an event  }
  462.     kInvalidDeviceNumber        = -9089;
  463.     kUnsupportedVsErr            = -9090;                        {  Unsupported Voltage Sense  }
  464.     kInvalidCSClientErr            = -9091;                        {  Card Services ClientID is not registered  }
  465.     kBadTupleDataErr            = -9092;                        {  Data in tuple is invalid  }
  466.     kBadCustomIFIDErr            = -9093;                        {  Custom interface ID is invalid  }
  467.     kNoIOWindowRequestedErr        = -9094;                        {  Request I/O window before calling configuration  }
  468.     kNoMoreTimerClientsErr        = -9095;                        {  All timer callbacks are in use  }
  469.     kNoMoreInterruptSlotsErr    = -9096;                        {  All internal Interrupt slots are in use  }
  470.     kNoClientTableErr            = -9097;                        {  The client table has not be initialized yet  }
  471.     kUnsupportedCardErr            = -9098;                        {  Card not supported by generic enabler }
  472.     kNoCardEnablersFoundErr        = -9099;                        {  No Enablers were found }
  473.     kNoEnablerForCardErr        = -9100;                        {  No Enablers were found that can support the card }
  474.     kNoCompatibleNameErr        = -9101;                        {  There is no compatible driver name for this device }
  475.     kClientRequestDenied        = -9102;                        {  CS Clients should return this code inorder to  }
  476.                                                                 {    deny a request-type CS Event                 }
  477.     kNotReadyErr                = -9103;                        {  PC Card failed to go ready  }
  478.     kTooManyIOWindowsErr        = -9104;                        {  device requested more than one I/O window  }
  479.     kAlreadySavedStateErr        = -9105;                        {  The state has been saved on previous call  }
  480.     kAttemptDupCardEntryErr        = -9106;                        {  The Enabler was asked to create a duplicate card entry  }
  481.     kCardPowerOffErr            = -9107;                        {  Power to the card has been turned off  }
  482.     kNotZVCapableErr            = -9108;                        {  This socket does not support Zoomed Video  }
  483.     kNoCardBusCISErr            = -9109;                        {  No valid CIS exists for this CardBus card  }
  484.  
  485. {$ALIGN RESET}
  486. {$POP}
  487.  
  488. {$SETC UsingIncludes := PCCardIncludes}
  489.  
  490. {$ENDC} {__PCCARD__}
  491.  
  492. {$IFC NOT UsingIncludes}
  493.  END.
  494. {$ENDC}
  495.